#include <iostream>
#include <vector>
#include <deque>
#include <queue>
#include <string>
#include <cstring>

using namespace std;

int T, n;  // 共有 T 组样例，每组样例各有 n 个程序
int timee[10];  // 保存每种语句执行时所需要的时间
int QT;   // CPU 分配给每个程序的时间
int val[30];   // 最多 26 个变量，val 数组保存每个变量的值 a[3] = 4 --> d = 4
int p[1005];   // 保护现场   p[3] = 5  --> 第 3 号程序让出 CPU 权限时，执行到第 5 条语句

vector<string> prg[30];   // 保存每个程序的语句
deque<int> ReadQ;    // 等待队列/就绪队列: CPU 从 ReadQ 的头部取出一个程序开始执行
queue<int> BlockQ;   // 阻塞队列: 当前程序被加锁，往后的程序进入 BlockQ

bool locked;   // 标记是否被枷锁
string s;  // 每一条指令

// 当前要执行第 i 个程序
void CPU(int i) {
    int t = QT;   // 防止 QT 被改变
    int v;

    while (t > 0) {
        string pCur;   // 当前要执行的是第 i 个程序的 pCur 这条语句
        pCur = prg[i][p[i]];    // 恢复现场

        switch (pCur[2]) {
            case '=': {
                t -= timee[0];

                v = pCur[4] - '0';
                if (pCur.size() == 6) {   // 赋值给变量的，是一个 2 位数
                    v = v * 10 + (pCur[5] - '0');
                }
                val[pCur[0] - 'a'] = v;
                break;
            }

            case 'i': {
               t -= timee[1];
               cout << i << ": " << val[pCur[6] - 'a'] << endl;
               break;
            }

            case 'c': {
                t -= timee[2];

                if(locked) {
                    BlockQ.push(i);   // 如果上一个程序处于加锁状态，当前程序直接进入阻塞队列
                    return;
                } else {
                    locked = true;
                }
                break;
            }

            case 'l': {
                t -= timee[3];
                locked = false;

                // 从阻塞队列中拿出元素，插入到 等待队列的头部，然后 CPU 从头部拿出程序去执行
                if(!BlockQ.empty()) {
                    int u = BlockQ.front();
                    BlockQ.pop();

                    ReadQ.push_front(u);
                }
                break;
            }

            case 'd': {
                return;
            }


        }
        // 需要保护现场
        p[i]++;
    }

    // 第 i 个程序还没执行完，那么再让出 CPU 权限之后，进入等待队列的尾部，等待再一次执行
    ReadQ.push_back(i);
}

int main() {
    cin >> T;
    while (T--) {
        cin >> n;  // 第 T 个程序有 n 条指令
        for(int i = 0; i < 5; i++) {
            cin >> timee[i];  // 得到每种语句的执行时间
        }
        cin >> QT;

        // 读取每个程序的所有语句
        memset(val, 0, sizeof(val));
        for(int i = 1; i <= n; i++) {
            prg[i].clear();
            while (getline(cin, s)) {
                prg[i].push_back(s);
                if(prg[i].back() == "end") {
                    break;
                }
            }

            ReadQ.push_back(i);  // 第 i 个程序进入等待队列，等待执行
        }

        memset(p, 0, sizeof(p));
        locked = false;   // 起始时，没有加锁

        // 开始执行: 只要等待队列中有程序，那么 CPU 就要执行
        while (!ReadQ.empty()) {
            int pid = ReadQ.front();   // 从等待队列的队头拿出一个程序开始执行
            ReadQ.pop_front();   // 删除队首元素

            CPU(pid);  // 第 pid 个程序开始执行
        }

        if(T) {
            cout << "\n";
        }
    }


    return 0;
}
